package org.jeecg.modules.simulator.rooter;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.modules.simulator.SimulatorParamLoader;
import org.jeecg.modules.simulator.factory.SimulatorDBFactory;
import org.jeecg.modules.simulator.factory.SimulatorFactory;
import org.jeecg.modules.simulator.model.SceneDataType;
import org.jeecg.modules.simulator.model.SceneParam;
import org.jeecg.modules.simulator.model.SimulatorParam;
import org.jeecg.modules.simulator.model.project.ProjectStatus;
import org.jeecg.modules.simulator.model.train.event.TrainListener;
import org.jeecg.modules.simulator.recorder.StationInfoVo;
import org.jeecg.modules.simulator.recorder.StationInstantInfo;
import org.jeecg.modules.simulator.service.HistoryBizPersonLoaderService;
import org.jeecg.modules.simulator.service.HistoryBizTrainLoaderService;
import org.jeecg.modules.simulator.service.QueryPasgrPeriodServiceImpl;
import org.jeecg.modules.simulator.service.T80RouteHisService;
import org.jeecg.modules.simulator.util.TimeUtil;
import org.jeecg.modules.simulator.util.UnitCache;
import org.jeecg.modules.simulator.vo.LineStaticInfoVo;
import org.jeecg.modules.simulator.vo.ProjectControlStatus;
import org.jeecg.modules.simulator.vo.SceneControlStatus;
import org.jeecg.modules.simulator.vo.StationStaticInfoVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.IOException;
import java.time.Duration;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Future;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * @program: simulator-b20240918
 * @description:
 * @author: renzhg
 * @create: 2024-10-04 13:47
 **/
@Slf4j
public class CaculateProject  implements Runnable {


    @Setter
    private RedisTemplate<String, Object> redisTemplate;
    private static final Logger logger = LoggerFactory.getLogger(CaculateProject.class);
    ProjectStatus projectStatus;
    private Thread nowThread;

    NetRooter netRooter=new NetRooter();

    LocalTime currentTime;
    DataManagerRooter dataManagerRooter=new DataManagerRooter();
    @Getter
    String sceneCode;

    SceneParam sceneParam;
    SimulatorParam simulatorParam;

    @Setter
    QueryPasgrPeriodServiceImpl queryPasgrPeriodService;

    @Setter
    HistoryBizTrainLoaderService historyBizTrainLoaderService;
    @Setter
    HistoryBizPersonLoaderService historyBizPersonLoaderService;

    DataLoadRooter dataLoadRooter=new DataLoadRooter();
    public CaculateProject(String sceneCode, TrainListener trainListener, RedisTemplate<String, Object> redisTemplate) {
        logger.debug("CaculateProject init");
        this.sceneCode=sceneCode;
        this.redisTemplate=redisTemplate;
        sceneParam = UnitCache.sceneParamMap.get(sceneCode);
        netRooter.setSceneCode(sceneCode);
        netRooter.setTrainListener(trainListener);
        netRooter.setQueryPasgrPeriodService(queryPasgrPeriodService);

        netRooter.setRedisTemplate(this.redisTemplate);
    }

    public void initProjectParam(){
        netRooter.setHistoryBizPersonLoaderService(historyBizPersonLoaderService);
        netRooter.setHistoryBizTrainLoaderService(historyBizTrainLoaderService);
    }

/**
 * @description:
 * 1、过滤基础数据
 * 3、加载业务数据，包括人员路径数据，列车时刻表（时刻表过滤分线路）、OD概率数据、每秒进站人数。
 *
 * @author:  renzhg
 * @date:  2024/11/29 11:07
 **/
    private void loadBizData() {
//
        netRooter.filterBasicData();
//        加载业务数据，包括人员路径数据，列车时刻表（时刻表过滤分线路）、OD概率数据、每秒进站人数。
        dataLoadRooter.setNetRooter(netRooter);
        dataLoadRooter.setHistoryBizTrainLoaderService(netRooter.historyBizTrainLoaderService);
        dataLoadRooter.setHistoryBizPersonLoaderService(netRooter.historyBizPersonLoaderService);
//        dataLoadRooter.setT80RouteHisService(this.t80RouteHisService);
        dataLoadRooter.loadBizData();
//        netRooter.dataLoadRootInit();
//        netRooter.loadBizData();
        dataManagerRooter.setDataLoadRooter(dataLoadRooter);


        netRooter.setRootPublisherParam();

    }

    public void loadDB() {

        netRooter.loadBasicData();

    }


//    public void initNetTrain(){
//        projectStatus=ProjectStatus.init;
////        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
////        LocalTime startTime=LocalTime.parse(startTimeString, formatter);
////              赋值每条线的场景参数
////        netRooter.initSceneCode2Line();
////        //给每条线分配站点表数据
////        netRooter.initLineStationMap();
////        netRooter.assignInitParam();
//
////        netRooter.routeAndStationMap2line();
//
//        dataManagerRooter.setNetRooter(netRooter);
//        dataManagerRooter.setNetStartTrainTime(netRooter.netStartTrainTime);
//        dataManagerRooter.setSceneCode(this.sceneCode);
//        dataManagerRooter.setNumPeopEnStationApiInfoMap(netRooter.numPeopEnStationApiInfoMap);
//        dataManagerRooter.initTrain();
//    }
    public void init() {

        projectStatus=ProjectStatus.init;
//        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
//        LocalTime startTime=LocalTime.parse(startTimeString, formatter);
//              赋值每条线的场景参数
//        netRooter.initSceneCode2Line();
//        //给每条线分配站点表数据
//        netRooter.initLineStationMap();
//        netRooter.assignInitParam();

//        netRooter.routeAndStationMap2line();

        dataManagerRooter.setNetRooter(netRooter);
        dataManagerRooter.setNetStartTrainTime(netRooter.netStartTrainTime);
        dataManagerRooter.setSceneCode(this.sceneCode);
        dataManagerRooter.setNumPeopEnStationApiInfoMap(netRooter.numPeopEnStationApiInfoMap);
        dataManagerRooter.initDataSet();//线路数据赋值
//        dataManagerRooter.initTrain();
        NetLineInitializer netLineInitializer = new NetLineInitializer();
        netLineInitializer.setLinesStationMap(netRooter.linesStationMap);
        netLineInitializer.setStationMap(netRooter.stationMap);

        netLineInitializer.setParkerMap(netRooter.parkerMap);
        netLineInitializer.setTrainPlanTableMapByLine(netRooter.trainPlanTableMapByLine);
        netLineInitializer.setLineRooterMap(netRooter.lineRooterMap);
        netLineInitializer.setPersonPathMap(netRooter.personPathMap);
        netLineInitializer.setSceneCode(sceneCode);
        // 生成一个RooterInitializer实例
        RooterInitializer rooterInitializer = dataManagerRooter.initRooterInitializer();
        rooterInitializer.initTrainTableBizData();//列车时刻表生成列车动作列表,将人员分配到列车上、以及设置站点和换乘站数据。
        rooterInitializer.queryODData2Line();
        //initNetTrain();
        initPerson();
        dataManagerRooter.initAfterSetData(rooterInitializer);
        dataManagerRooter.setTrainListenerParam();
        //列车时刻表装配,线路生成，列车动作对象生成，人员路径信息查询分配都在这个方法中----重要
//        netRooter.DMRInit();
//        RooterInitializer   rooterInitializer =netRooter.initData();
//        netRooter.initAfterSetData(rooterInitializer);// 初始化后，提取结果数据，生成打印对象
//        netRooter.setTrainListenerParam();
    }

    //给god赋初始化的值
    private void initPerson() {

        netRooter.getGod().setGodAssistanter(netRooter.godAssistanter);
        netRooter.getGod().setSceneCode(netRooter.getSceneCode());
        netRooter.getGod().setOdProbabilityApiInfoMap(this.netRooter.odProbabilityApiInfoMap);
        netRooter.getGod().setNumPeopEnStationApiInfoMap(this.netRooter.numPeopEnStationApiInfoMap);
        netRooter.getGod().setStationMap(this.netRooter.stationMap);
        netRooter.getGod().setTransferStationMap(this.netRooter.transferStationMap);
        netRooter.getGod().setRedisTemplate(this.redisTemplate);
        netRooter.getGod().setLineRooterMap(this.netRooter.lineRooterMap);



    }

//    private void initSimulator() {
//        netRooter.parameterConfig();
//    }

    public void runProgram() {
        try {

            // 设定时间、仿真线路
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");

            if(sceneParam.getSceneType().equals(SceneDataType.allDayHistoryData)){
                String netStartTime=netRooter.getNetStartTrainTime();
                SceneControlStatus sceneControlStatus1 = UnitCache.sceneControlStatusMap.get(sceneCode);
//                LocalTime.parse(netStartTime, formatter);
                LocalTime firstActionTime = LocalTime.parse(netStartTime, formatter);
                LocalTime clonedTime = firstActionTime.withNano(firstActionTime.getNano());
                LocalTime updatedTime = clonedTime.minusSeconds(2);
                LocalTime now = updatedTime;
                Duration startDuration = Duration.between(firstActionTime, sceneParam.getEndTime());
                sceneControlStatus1.setTimePt(now.toString());
                sceneControlStatus1.setStartTimeL(startDuration.getSeconds());
                UnitCache.sceneControlStatusMap.put(sceneCode,sceneControlStatus1);
                currentTime = updatedTime;
                startLoop(now);
            }else{

                SceneParam sceneParam1=   UnitCache.sceneParamMap.get(sceneCode);
                LocalTime firstActionTime = LocalTime.parse(sceneParam1.getStartTimeStr(), formatter);
                LocalTime clonedTime = firstActionTime.withNano(firstActionTime.getNano());
                LocalTime updatedTime = clonedTime.minusSeconds(2);
                LocalTime now = updatedTime;
                currentTime = updatedTime;
                startLoop(now);
            }


//             LocalTime.parse(now.toString(), formatter2);




        } catch (Exception e) {
            e.printStackTrace();

        }


    }

    private void startLoop(LocalTime nowLocalTime) throws InterruptedException {
        LocalTime startTime = nowLocalTime;
        LocalTime endTime = sceneParam.getEndTime();
        logger.debug("开始时间：" + startTime.toString());
        logger.debug("结束时间：" + endTime.toString());

        String nowTime1="";
        if(TimeUtil.containsSeconds(nowLocalTime.toString())) {
            nowTime1=nowLocalTime.toString();
        }else{
            nowTime1=nowLocalTime.toString()+":00";
        }
        projectStatus=ProjectStatus.running;
        SceneControlStatus sceneControlStatus1 = UnitCache.sceneControlStatusMap.get(sceneCode);
        sceneControlStatus1.setTimePt(nowTime1);
//        sceneControlStatus1.setTimePt(now.toString());
        UnitCache.sceneControlStatusMap.put(sceneCode,sceneControlStatus1);
        SceneControlStatus sceneControlStatus = UnitCache.sceneControlStatusMap.get(this.sceneCode);
        sceneControlStatus.setProjectControlStatus(ProjectControlStatus.running);

        SceneParam sceneParam = UnitCache.sceneParamMap.get(sceneCode);
        LocalTime sceneStartTime = sceneParam.getStartTime();
        while (nowLocalTime.isBefore(endTime)) {


//            Future<?> future = UnitCache.sceneFutureMap.get(sceneCode);
//            future.cancel(true);
            String nowTime="";
            if(TimeUtil.containsSeconds(nowLocalTime.toString())) {
                nowTime=nowLocalTime.toString();
            }else{
                nowTime=nowLocalTime.toString()+":00";
            }
            SceneControlStatus sceneControlStatus2 = UnitCache.sceneControlStatusMap.get(sceneCode);
//            if(sceneControlStatus2.getProjectControlStatus().equals(ProjectControlStatus.stop)){
//                future.cancel(true);
//            }

            logger.debug("当前时间：" + currentTime.toString());
            netRooter.UpdateCurrentTime(currentTime);

            sceneControlStatus2.setTimePt(nowTime);
            UnitCache.sceneControlStatusMap.put(sceneCode,sceneControlStatus2);

            int step2=sceneControlStatus2.getStep();
            event();
            System.out.println("运行时间点："+nowTime);
            long startTime1 = System.nanoTime();//检查这个站是否有
            netRooter.nextTime(nowTime, 1  );
            long endTime1 = System.nanoTime();
            long duration1 = endTime1 - startTime1;
            System.out.println("程序运行时间: duration1=" + duration1  / 1_000_000+" 毫秒");

            event();


            if(!nowLocalTime.isBefore(sceneStartTime)){
                Thread.sleep(1 * step2);
            }

            // 如果需要暂停，直到 running 变为 true
            if (!getCurrnetIsRuning()) {
                synchronized (CaculateProject.class) {
                    while (!getCurrnetIsRuning()) {
                        CaculateProject.class.wait(); // 等待被唤醒
                    }
                }
            }

            nowLocalTime = nowLocalTime.plusSeconds(1);
            currentTime = currentTime.plusSeconds(1);
        }

//        StationInfoVo stationInfoVo = UnitCache.stationInfoVoMap.get(sceneCode);
//        writeStationInstantInfoToFiles(stationInfoVo.getStationInstantInfoMap());

    }

    public static final String COMMON_DIRECTORY = "D:/aaaaaa/stationjsonfile/";



    public   void resume(String sceneCode) {

        SceneControlStatus sceneControlStatus = UnitCache.sceneControlStatusMap.get(sceneCode);
        sceneControlStatus.setProjectControlStatus(ProjectControlStatus.running);
//        running = true; // 设置为继续状态
        synchronized (CaculateProject.class) {
            CaculateProject.class.notifyAll(); // 唤醒等待的线程
        }
    }

    public void stopProgram() {
//        if (nowThread != null) {
//            nowThread.interrupt(); // 中断线程，允许其清理资源
//            try {
//                nowThread.join(); // 等待线程完成
//            } catch (InterruptedException e) {
//                Thread.currentThread().interrupt(); // 处理线程中断
//            }
//        }
    }
    private boolean getCurrnetIsRuning() {

        SceneControlStatus sceneControlStatus = UnitCache.sceneControlStatusMap.get(this.sceneCode);
        if(sceneControlStatus.getProjectControlStatus().equals(ProjectControlStatus.pause)){
            return false;
        }else if(sceneControlStatus.getProjectControlStatus().equals(ProjectControlStatus.running)){
            return true;
        }
        return false;

    }

    public static  void pause(String sceneCode) {
        SceneControlStatus sceneControlStatus = UnitCache.sceneControlStatusMap.get(sceneCode);
        sceneControlStatus.setProjectControlStatus(ProjectControlStatus.pause);
    }

//    private boolean getCurrnetIsRuning() {
//
//        SceneControlStatus sceneControlStatus = UnitCache.sceneControlStatusMap.get(this.sceneCode);
//        if(sceneControlStatus.getProjectControlStatus().equals(ProjectControlStatus.pause)){
//            return false;
//        }else if(sceneControlStatus.getProjectControlStatus().equals(ProjectControlStatus.running)){
//            return true;
//        }
//return false;
//
//    }



    private Integer checkStep(Integer curStep) {


        return curStep;

    }


//线路组装

    SimulatorDBFactory  simulatorDBFactory=new SimulatorDBFactory();
    /**
     * @description: 加载模拟器运行所必须的数据
     * 业务1：可以根据参数来确定选择几条线路参与仿真计算
     * 要有的参数1、
     * @author: renzhg
     * @date: 2024/8/19 10:18
     **/
    private void loadSimulator() {


        simulatorDBFactory.loadSimulator();
//        SimulatorParamLoader simulatorFactory = new SimulatorFactory();
//
//        simulatorFactory.loadSimulator();
        netRooter.setSimulatorParam(simulatorDBFactory.getSimulatorParam());
        simulatorParam = simulatorDBFactory.getSimulatorParam();


        UnitCache.simulatorParamMap.put(netRooter.sceneCode, simulatorParam);
        UnitCache.globalSceneBaseData.getLineMap().forEach((k, v) -> {
            if(simulatorParam.getShowLines().contains(k)){
                UnitCache.globalSceneBaseData.getLineFilterMap().put(k,v);
            }

        });
        UnitCache.globalSceneBaseData.getLineStationMap().forEach((k, v) -> {
            if(simulatorParam.getShowLines().contains(k)){
                UnitCache.globalSceneBaseData.getLineFilterStationMap().put(k,v);
            }

        });
        UnitCache.globalSceneBaseData.getParkerMap().forEach((k,v)->{
            if(simulatorParam.getShowLines().contains(k)){
                UnitCache.globalSceneBaseData.getParkerFilterMap().put(k,v);
            }
        });
        UnitCache.globalSceneBaseData.getOrbitPointListMap().forEach((k,v)->{
            if(simulatorParam.getShowLines().contains(k)){
                UnitCache.globalSceneBaseData.getOrbitFilterPointListMap().put(k,v);
            }
        });



//        netRooter.setDailyPassengerVolume(simulatorFactory.getSimulatorParam().getDailyPassengerVolume());
//        if (startTimeString == null || endTimeString == null) {
//            throw new RuntimeException("请先定义时间范围");
//        }


    }


    /**
     * @description: 计算每秒下车人数
     * @author: renzhg
     * @date: 2024/9/30 15:18
     **/
    public void caculateNetAllPersonSizePSec() {
//        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("HH:mm");
//        LocalTime startTime = LocalTime.parse(startTimeString, formatter2);
//        LocalTime endTime = LocalTime.parse(endTimeString, formatter2);

        int perssecsize = netRooter.getAverageNetAllPersonSizePSec(simulatorDBFactory.getSimulatorParam().getStartTime(), simulatorDBFactory.getSimulatorParam().getEndTime());
        netRooter.setNetAllPersonSizePSec(perssecsize);
        netRooter.generateNetAllPersonSizePSecMap();
    }


    public void event() {

    }

    //检查方案是否修改
    public void checkSimulator() {

    }

    public void projectRun(){
        runProgram();
    }

    public void projectInit(){
        loadDB();
        event();
        loadSimulator();
        /**
         * @description: 
         *
         * @author:  renzhg 
         * @date:  2024/11/29 14:00
         **/
        loadBizData();//加载业务数据
        event();
        init();//计算各个数据所需要的比率
        event();
        logger.debug("初始化结束");
    }

    @Override
    public void run() {
        nowThread = Thread.currentThread();
        runProgram();
    }

    public void stop() {
        SceneControlStatus sceneControlStatus = UnitCache.sceneControlStatusMap.get(sceneCode);
        synchronized (CaculateProject.class) {
            CaculateProject.class.notifyAll(); // 唤醒可能在等待的线程
        }
    }

    public Map<String, StationStaticInfoVo> afeterInitGetStationInfo() {
        Map<String ,StationStaticInfoVo> stationStaticInfoVoMap = new HashMap<>();

        netRooter.stationMap.forEach((k,v)->{
            StationStaticInfoVo stationStaticInfoVo = new StationStaticInfoVo();
            stationStaticInfoVo.setStationId(v.getId());
            stationStaticInfoVo.setStationName(v.getName());
            stationStaticInfoVo.setOpen(v.isOpen());
            stationStaticInfoVo.setOpen(false);
            stationStaticInfoVo.setInterFaceNum(v.getEntryExitGateMap().size());
            Map<String,Integer> interFaceMap = new HashMap<>();
            v.getEntryExitGateMap().forEach((k1,v1)->{
                interFaceMap.put(k1,v1.getLimitSpeed());
            });
            stationStaticInfoVo.setInterFaceMap(interFaceMap);
            stationStaticInfoVo.setHallState(v.getStationConcourser().isOpen());
            stationStaticInfoVo.setHallMaxSpeed(v.getStationConcourser().getLimitSpeed());
            stationStaticInfoVo.setHallArea(v.getStationConcourser().getArea());
            stationStaticInfoVo.setHallPassTime(v.getStationConcourser().getCrossTime());


            stationStaticInfoVo.setPlatformArea(v.getStationPlatform().getArea());
            stationStaticInfoVo.setPlatformType("岛式");
            stationStaticInfoVo.setUpLimitSpeed(v.getStationPlatform().getUpLimitSpeed());
            stationStaticInfoVo.setDownLimitSpeed(v.getStationPlatform().getDownLimitSpeed());
            stationStaticInfoVo.setPlatformPassTime(v.getStationPlatform().getCrossTime());
            stationStaticInfoVoMap.put(k,stationStaticInfoVo);

        });
        netRooter.transferStationMap.forEach((k,v)-> {
            stationStaticInfoVoMap.values().forEach((v1) -> {
                if (v1.getStationName().equals(v.getName())) {
                    v1.setTransfer(true);
                }
            });
        });
        return stationStaticInfoVoMap;
    }


    public LineStaticInfoVo afterInitGetLineStaticInfo() {
        LineStaticInfoVo lineStaticInfoVo = new LineStaticInfoVo();
//        Map<String,Integer> lineStationNumMap = new HashMap<>();

        List<String> lineStationNumList=new ArrayList<>();
        netRooter.lineMap.forEach((k,v)->{
//            lineStationNumMap.put(k,v.getStationMap().size());
            lineStationNumList.add(k+"-"+v.getStationMap().size());
        });
        lineStaticInfoVo.setLineStationNumList(lineStationNumList);
//        lineStaticInfoVo.setLineStationNumMap(lineStationNumMap);
      int currentStationNum = netRooter.stationAllMap.size();
      lineStaticInfoVo.setCurrentOpenStationNum(currentStationNum);

      Map<String,String> controlDepotNameMap = new HashMap<>();
        List<String> controlDepotNameList=new ArrayList<>();
        controlDepotNameList.add("一号线-十三号街车辆段");
//        controlDepotNameMap.put("一号线","十三号街车辆段");
        controlDepotNameList.add("二号线-浑南车辆段;桃仙停车场");
//        controlDepotNameMap.put("二号线","浑南车辆段;桃仙停车场");
        controlDepotNameList.add("四号线-文官屯车辆段;航天南路停车场");
//        controlDepotNameMap.put("四号线","文官屯车辆段;航天南路停车场");
        controlDepotNameList.add("九号线-曹仲车辆段");
//        controlDepotNameMap.put("九号线","曹仲车辆段");
       controlDepotNameList.add("十号线-桑林子车辆段;丁香湖停车场");
//        controlDepotNameMap.put("十号线","桑林子车辆段;丁香湖停车场");
        lineStaticInfoVo.setControlDepotNameList(controlDepotNameList);
//        lineStaticInfoVo.setControlDepotNameMap(controlDepotNameMap);
//        Map<String,Integer> NumberOfVehiclesMap = new HashMap<>();
        List<String> NumberOfVehiclesList=new ArrayList<>();
//        NumberOfVehiclesMap.put("一号线",23);
        NumberOfVehiclesList.add("一号线-23");
        NumberOfVehiclesList.add("二号线-74");
        NumberOfVehiclesList.add("四号线-35");
        NumberOfVehiclesList.add("九号线-30");
        NumberOfVehiclesList.add("十号线-27");

//        NumberOfVehiclesMap.put("二号线",74);
//        NumberOfVehiclesMap.put("四号线",35);
//        NumberOfVehiclesMap.put("九号线",30);
//        NumberOfVehiclesMap.put("十号线",27);
//        lineStaticInfoVo.setNumberOfVehiclesMap(NumberOfVehiclesMap);
        lineStaticInfoVo.setNumberOfVehiclesList(NumberOfVehiclesList);
        Map<String,Integer> NumberOfTrainsInLineMap=new HashMap<>();
        List<String> NumberOfTrainsInLineList=new ArrayList<>();
        netRooter.getLineRooterMap().forEach((k,v)->{
//            NumberOfTrainsInLineMap.put(k,v.getTrainManager().getTrainMap().size());
            NumberOfTrainsInLineList.add(k+"-"+v.getTrainManager().getTrainMap().size());
        });
        lineStaticInfoVo.setNumberOfTrainsInLineList(NumberOfTrainsInLineList);
//        lineStaticInfoVo.setNumberOfTrainsInLineMap(NumberOfTrainsInLineMap);


        return lineStaticInfoVo;
    }
}
